/**
 * 商品控制器 - 整合pub、sys和主控制器功能
 * 提供完整的商品管理功能，包括公共接口、系统管理接口和基础接口
 */

const db = uniCloud.database();
const _ = db.command;

// 引入商品服务层
const ProductService = require('../service/product.service');
const productService = new ProductService();

/**
 * 商品控制器类
 * 整合了pub、sys和基础功能
 */
class ProductController {
    
    // ==================== 公共接口 (无需权限) ====================
    
    /**
     * 获取热门商品列表（公共接口）
     * @param {Object} params 查询参数
     * @param {Object} event 事件对象，包含客户端信息
     * @param {Object} context 上下文对象
     * @param {number} params.limit - 返回数量限制
     * @returns {Promise<Array>} 热门商品列表
     */
    async getHotProducts(params = {}) {
        try {
            const { limit = 10 } = params;
            return await productService.getHotProducts(limit);
        } catch (error) {
            console.error('获取热门商品失败:', error);
            throw new Error(`获取热门商品失败: ${error.message}`);
        }
    }
    
    /**
     * 获取商品分类列表（公共接口）
     * @param {Object} params 查询参数
     * @returns {Promise<Array>} 分类列表
     */
    async getCategories(params) {
        try {
            return await productService.getCategories(params);
        } catch (error) {
            console.error('获取分类列表失败:', error);
            throw new Error(`获取分类列表失败: ${error.message}`);
        }
    }
    
    /**
     * 搜索商品（公共接口）
     * @param {Object} params 搜索参数
     * @returns {Promise<Object>} 搜索结果
     */
    async searchProducts(params) {
        try {
            return await productService.searchProducts(params);
        } catch (error) {
            console.error('搜索商品失败:', error);
            throw new Error(`搜索商品失败: ${error.message}`);
        }
    }
    
    /**
     * 获取商品推荐列表（公共接口）
     * @param {Object} params 推荐参数
     * @returns {Promise<Array>} 推荐列表
     */
    async getRecommendations(params) {
        try {
            return await productService.getRecommendations(params);
        } catch (error) {
            console.error('获取推荐商品失败:', error);
            throw new Error(`获取推荐商品失败: ${error.message}`);
        }
    }
    
    
    /**
     * 获取商品评价统计（公共接口）
     * @param {Object} params 商品ID
     * @returns {Promise<Object>} 评价统计
     */
    async getReviewStats(params) {
        try {
            return await productService.getReviewStats(params);
        } catch (error) {
            console.error('获取评价统计失败:', error);
            throw new Error(`获取评价统计失败: ${error.message}`);
        }
    }
    
    /**
     * 获取新品商品（公共接口）
     * @param {Object} params - 查询参数
     * @param {number} params.limit - 返回数量限制
     * @returns {Promise<Array>} - 返回新品商品列表
     */
    async getNewProducts(params = {}) {
        try {
            const { limit = 10 } = params;
            return await productService.getNewProducts(limit);
        } catch (error) {
            console.error('获取新品商品失败:', error);
            throw new Error(`获取新品商品失败: ${error.message}`);
        }
    }
    
    /**
     * 获取分销商品（公共接口）
     * @param {Object} params - 查询参数
     * @param {number} params.page - 页码
     * @param {number} params.pageSize - 每页数量
     * @returns {Promise<Object>} - 返回分销商品列表
     */
    async getDistributionProducts(params) {
        try {
            return await productService.getDistributionProducts(params);
        } catch (error) {
            console.error('获取分销商品失败:', error);
            throw new Error(`获取分销商品失败: ${error.message}`);
        }
    }
    
    // ==================== 基础接口 (需要登录) ====================
    
    /**
	 * 获取商品列表
	 * @param {Object} params - 查询参数
	 * @param {number} params.page - 页码
	 * @param {number} params.pageSize - 每页数量
	 * @param {string} params.categoryId - 分类ID
	 * @param {string} params.keyword - 搜索关键词
	 * @param {string} params.sortBy - 排序字段
	 * @param {string} params.sortOrder - 排序顺序
	 * @param {number} params.minPrice - 最低价格
	 * @param {number} params.maxPrice - 最高价格
	 * @param {number} params.status - 商品状态
	 * @returns {Promise<Object>} - 返回商品列表和分页信息
	 */
    async getProductList(params) {
        try {
            return await productService.getProductList(params);
        } catch (error) {
            console.error('获取商品列表失败:', error);
            throw new Error(`获取商品列表失败: ${error.message}`);
        }
    }
    
    /**
     * 获取商品详情（需要登录）
     * @param {Object} params - 查询参数
     * @returns {Promise<Object>} - 返回商品详情
     */
    async getProductDetail(params) {
        try {
            const { productId } = params;
            if (!productId) {
                throw new Error('商品ID不能为空');
            }
            
            return await productService.getProductDetail(productId);
        } catch (error) {
            console.error('获取商品详情失败:', error);
            throw new Error(`获取商品详情失败: ${error.message}`);
        }
    }
    
    // ==================== 系统管理接口 (需要管理员权限) ====================
    
    /**
     * 创建商品（需要管理员权限）
     * @param {Object} params - 商品信息
     * @returns {Promise<Object>} - 返回创建结果
     */
    async createProduct(params) {
        try {
            // 从event中获取用户信息（中间件已注入）
            const userInfo = this.userInfo;
            
            // 添加用户信息到参数中
            params.uid = userInfo.uid;
            params.userInfo = userInfo;

            return await productService.createProduct(params);
        } catch (error) {
            console.error('创建商品失败:', error);
            throw new Error(`创建商品失败: ${error.message}`);
        }
    }
    
    /**
     * 更新商品（需要管理员权限）
     * @param {Object} params - 更新参数
     * @returns {Promise<Object>} - 返回更新结果
     */
    async updateProduct(params) {
        try {
            const { productId } = params;
            if (!productId) {
                throw new Error('商品ID不能为空');
            }

            // 从event中获取用户信息（中间件已注入）
            const userInfo = this.userInfo;
            
            // 添加用户信息到参数中
            params.uid = userInfo.uid;
            params.userInfo = userInfo;

            return await productService.updateProduct(params);
        } catch (error) {
            console.error('更新商品失败:', error);
            throw new Error(`更新商品失败: ${error.message}`);
        }
    }
    
    /**
     * 删除商品（需要管理员权限）
     * @param {Object} params - 删除参数
     * @returns {Promise<Object>} - 返回删除结果
     */
    async deleteProduct(params) {
        try {
            const { productId } = params;
            if (!productId) {
                throw new Error('商品ID不能为空');
            }

            // 从event中获取用户信息（中间件已注入）
            const userInfo = this.userInfo;
            
            // 添加用户信息到参数中
            params.uid = userInfo.uid;
            params.userInfo = userInfo;

            return await productService.deleteProduct(productId);
        } catch (error) {
            console.error('删除商品失败:', error);
            throw new Error(`删除商品失败: ${error.message}`);
        }
    }
    
    /**
     * 批量更改商品状态（需要管理员权限）
     * @param {Object} params - 操作参数
     * @returns {Promise<Object>} - 返回操作结果
     */
    async batchChangeStatus(params) {
        try {
            const { productIds, status } = params;
            if (!productIds || !Array.isArray(productIds) || productIds.length === 0) {
                throw new Error('商品ID列表不能为空');
            }

            // 从event中获取用户信息（中间件已注入）
            const userInfo = this.userInfo;
            
            // 添加用户信息到参数中
            params.uid = userInfo.uid;
            params.userInfo = userInfo;

            return await productService.batchChangeStatus(productIds, status);
        } catch (error) {
            console.error('批量更改商品状态失败:', error);
            throw new Error(`批量更改商品状态失败: ${error.message}`);
        }
    }
    
    /**
     * 获取商品统计信息（需要管理员权限）
     * @param {Object} params 查询参数
     * @returns {Object} 统计信息
     */
    async getProductStats(params) {
        try {
            // 模拟获取商品统计
            const stats = {
                totalProducts: 150,
                onSaleProducts: 120,
                soldOutProducts: 30,
                totalViews: 5000,
                totalSales: 300,
                totalRevenue: 150000
            };
            
            return {
                code: 200,
                message: '获取成功',
                data: stats
            };
        } catch (error) {
            return {
                code: 500,
                message: '获取失败',
                data: null
            };
        }
    }
    
    /**
     * 批量更新商品状态（需要管理员权限）
     * @param {Object} params 更新参数
     * @returns {Object} 操作结果
     */
    async batchUpdateStatus(params) {
        try {
            const { productIds, status } = params;
            
            // 模拟批量更新
            return {
                code: 200,
                message: '批量更新成功',
                data: {
                    updatedCount: productIds.length,
                    status: status
                }
            };
        } catch (error) {
            return {
                code: 500,
                message: '批量更新失败',
                data: null
            };
        }
    }
    
    /**
     * 获取商品审核列表（需要管理员权限）
     * @param {Object} params 查询参数
     * @returns {Object} 审核列表
     */
    async getReviewList(params) {
        try {
            // 模拟获取审核列表
            const reviewList = [
                { id: 1, productName: '待审核商品1', submitTime: '2024-01-01', status: 'pending' },
                { id: 2, productName: '待审核商品2', submitTime: '2024-01-02', status: 'pending' }
            ];
            
            return {
                code: 200,
                message: '获取成功',
                data: reviewList
            };
        } catch (error) {
            return {
                code: 500,
                message: '获取失败',
                data: null
            };
        }
    }
    
    /**
     * 审核商品（需要管理员权限）
     * @param {Object} params 审核参数
     * @returns {Object} 审核结果
     */
    async reviewProduct(params) {
        try {
            const { productId, reviewStatus, reviewComment } = params;
            
            // 模拟审核逻辑
            return {
                code: 200,
                message: '审核成功',
                data: {
                    productId,
                    reviewStatus,
                    reviewComment,
                    reviewedAt: new Date()
                }
            };
        } catch (error) {
            return {
                code: 500,
                message: '审核失败',
                data: null
            };
        }
    }
    
    /**
     * 获取商品操作日志（需要管理员权限）
     * @param {Object} params 查询参数
     * @returns {Object} 操作日志
     */
    async getOperationLogs(params) {
        try {
            // 模拟获取操作日志
            const logs = [
                { id: 1, operator: 'admin', action: 'create', target: '商品1', time: '2024-01-01 10:00:00' },
                { id: 2, operator: 'admin', action: 'update', target: '商品2', time: '2024-01-01 11:00:00' }
            ];
            
            return {
                code: 200,
                message: '获取成功',
                data: logs
            };
        } catch (error) {
            return {
                code: 500,
                message: '获取失败',
                data: null
            };
        }
    }
}

module.exports = { ProductController };